// numeric standard header
#pragma once
#ifndef _NUMERIC_
#define _NUMERIC_
#ifndef RC_INVOKED
#include <iterator>
#include <xutility>

 #include <functional>

#ifdef _MSC_VER
 #pragma pack(push,_CRT_PACKING)
 #pragma warning(push,3)
#endif  /* _MSC_VER */

_STD_BEGIN

		// TEMPLATE FUNCTION accumulate
template<class _InIt,
	class _Ty> inline
	_Ty _Accumulate(_InIt _First, _InIt _Last, _Ty _Val)
	{	// return sum of _Val and all in [_First, _Last)
	_DEBUG_RANGE(_First, _Last);
	for (; _First != _Last; ++_First)
		_Val = _Val + *_First;
	return (_Val);
	}

template<class _InIt,
	class _Ty> inline
	_Ty accumulate(_InIt _First, _InIt _Last, _Ty _Val)
	{	// return sum of _Val and all in [_First, _Last)
	return _Accumulate(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Val);
	}

		// TEMPLATE FUNCTION accumulate WITH BINOP
template<class _InIt,
	class _Ty,
	class _Fn2> inline
	_Ty _Accumulate(_InIt _First, _InIt _Last, _Ty _Val, _Fn2 _Func)
	{	// return sum of _Val and all in [_First, _Last), using _Func
	_DEBUG_RANGE(_First, _Last);
	_DEBUG_POINTER(_Func);
	for (; _First != _Last; ++_First)
		_Val = _Func(_Val, *_First);
	return (_Val);
	}

template<class _InIt,
	class _Ty,
	class _Fn2> inline
	_Ty accumulate(_InIt _First, _InIt _Last, _Ty _Val, _Fn2 _Func)
	{	// return sum of _Val and all in [_First, _Last), using _Func
	return _Accumulate(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Val, _Func);
	}

		// TEMPLATE FUNCTION inner_product
template<class _InIt1, class _InIt2, class _Ty, class _InItCats>
inline
	_Ty _Inner_product(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val,
		_InItCats, _Range_checked_iterator_tag)
	{	// return inner product of sequences
	_DEBUG_RANGE(_First1, _Last1);
	for (; _First1 != _Last1; ++_First1, ++_First2)
		_Val = _Val + *_First1 * *_First2;
	return (_Val);
	}

#if _SECURE_SCL
template<class _InIt1, class _InIt2, class _Ty>
inline
	_Ty _Inner_product(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val,
		random_access_iterator_tag, _Range_checked_iterator_tag)
	{
	// for range checked iterators, this will make sure there is enough space
	_InIt2 _Last2 = _First2 + (_Last1 - _First1); (_Last2);
	return _Inner_product(_First1, _Last1, _CHECKED_BASE(_First2), _Val,
		forward_iterator_tag(), _Range_checked_iterator_tag());
	}
#endif

#if _SECURE_SCL

template<class _InIt1, class _InIt2, class _Ty>
inline
_IF_CHK_(_InIt2, _Ty) inner_product(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val)
	{
	return _Inner_product(_CHECKED_BASE(_First1), _CHECKED_BASE(_Last1), _First2, _Val,
		_Iter_random(_First1, _First2), _STD _Range_checked_iterator_tag());
	}

template<class _InIt1, class _InElem2, class _Ty, size_t _Size>
inline
_Ty inner_product(_InIt1 _First1, _InIt1 _Last1, _InElem2 (&_First2)[_Size], _Ty _Val)
	{
	return inner_product(_First1, _Last1,
		_STDEXT make_checked_array_iterator(_First2, _Size), _Val);
	}

template<class _InIt1, class _InIt2, class _Ty>
inline
_SCL_INSECURE_DEPRECATE
_IF_NOT_CHK_(_InIt2, _Ty) inner_product(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val)
	{
	return _Inner_product(_CHECKED_BASE(_First1), _CHECKED_BASE(_Last1), _First2, _Val,
		_Iter_random(_First1, _First2), _STD _Range_checked_iterator_tag());
	}

#else

template<class _InIt1, class _InIt2, class _Ty>
inline
	_Ty inner_product(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val)
	{
	return _Inner_product(_CHECKED_BASE(_First1), _CHECKED_BASE(_Last1), _First2, _Val,
		_Iter_random(_First1, _First2), _STD _Range_checked_iterator_tag());
	}

#endif

		// TEMPLATE FUNCTION inner_product WITH BINOPS
template<class _InIt1, class _InIt2, class _Ty, class _Fn21, class _Fn22, class _InItCats>
inline
	_Ty _Inner_product(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val,
		_Fn21 _Func1, _Fn22 _Func2,
		_InItCats, _Range_checked_iterator_tag)
	{	// return inner product of sequences, using _Func1 and _Func2
	_DEBUG_RANGE(_First1, _Last1);
	_DEBUG_POINTER(_Func1);
	_DEBUG_POINTER(_Func2);
	for (; _First1 != _Last1; ++_First1, ++_First2)
		_Val = _Func1(_Val, _Func2(*_First1, *_First2));
	return (_Val);
	}

#if _SECURE_SCL
template<class _InIt1, class _InIt2, class _Ty, class _Fn21, class _Fn22>
inline
	_Ty _Inner_product(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val,
		_Fn21 _Func1, _Fn22 _Func2,
		random_access_iterator_tag, _Range_checked_iterator_tag)
	{
	// for range checked iterators, this will make sure there is enough space
	_InIt2 _Last2 = _First2 + (_Last1 - _First1); (_Last2);
	return _Inner_product(_First1, _Last1, _CHECKED_BASE(_First2), _Val, _Func1, _Func2,
		forward_iterator_tag(), _Range_checked_iterator_tag());
	}
#endif

#if _SECURE_SCL

template<class _InIt1, class _InIt2, class _Ty, class _Fn21, class _Fn22>
inline
_IF_CHK_(_InIt2, _Ty) inner_product(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val,
		_Fn21 _Func1, _Fn22 _Func2)
	{
		return _Inner_product(_CHECKED_BASE(_First1), _CHECKED_BASE(_Last1), _First2, _Val, _Func1, _Func2,
			_Iter_random(_First1, _First2), _STD _Range_checked_iterator_tag());
	}

template<class _InIt1, class _InElem2, class _Ty, class _Fn21, class _Fn22, size_t _Size>
inline
_Ty inner_product(_InIt1 _First1, _InIt1 _Last1, _InElem2 (&_First2)[_Size], _Ty _Val,
		_Fn21 _Func1, _Fn22 _Func2)
	{
		return inner_product(_First1, _Last1,
			_STDEXT make_checked_array_iterator(_First2, _Size),
			_Val, _Func1, _Func2);
	}

template<class _InIt1, class _InIt2, class _Ty, class _Fn21, class _Fn22>
inline
_SCL_INSECURE_DEPRECATE
_IF_NOT_CHK_(_InIt2, _Ty) inner_product(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val,
		_Fn21 _Func1, _Fn22 _Func2)
	{
		return _Inner_product(_CHECKED_BASE(_First1), _CHECKED_BASE(_Last1), _First2, _Val, _Func1, _Func2,
			_Iter_random(_First1, _First2), _STD _Range_checked_iterator_tag());
	}

#else

template<class _InIt1, class _InIt2, class _Ty, class _Fn21, class _Fn22>
inline
	_Ty inner_product(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val,
		_Fn21 _Func1, _Fn22 _Func2)
	{
		return _Inner_product(_CHECKED_BASE(_First1), _CHECKED_BASE(_Last1), _First2, _Val, _Func1, _Func2,
			_Iter_random(_First1, _First2), _STD _Range_checked_iterator_tag());
	}

#endif

		// TEMPLATE FUNCTION partial_sum
template<class _InIt, class _OutIt, class _Ty, class _InOutItCat>
inline
	_OutIt _Partial_sum(_InIt _First, _InIt _Last, _OutIt _Dest,
		_Ty *, _InOutItCat, _Range_checked_iterator_tag)
	{	// compute partial sums into _Dest
	_DEBUG_RANGE(_First, _Last);
	_DEBUG_POINTER(_Dest);
	_Ty _Val = *_First;
	for (*_Dest = _Val; ++_First != _Last; *++_Dest = _Val)
		_Val = _Val + *_First;
	return (++_Dest);
	}

#if _SECURE_SCL
template<class _InIt, class _OutIt, class _Ty>
inline
	_OutIt _Partial_sum(_InIt _First, _InIt _Last, _OutIt _Dest,
		_Ty *_Val_type, random_access_iterator_tag, _Range_checked_iterator_tag)
	{
	// for range checked iterators, this will make sure there is enough space
	_OutIt _Result = _Dest + (_Last - _First);
	_Partial_sum(_First, _Last, _CHECKED_BASE(_Dest),
		_Val_type, forward_iterator_tag(), _Range_checked_iterator_tag());
	return _Result;
	}
#endif

#if _SECURE_SCL

template<class _InIt, class _OutIt>
inline
_IF_CHK(_OutIt) partial_sum(_InIt _First, _InIt _Last, _OutIt _Dest)
	{	// compute partial sums into _Dest
	return (_First == _Last ? _Dest
		: _Partial_sum(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Dest,
			_Val_type(_First), _Iter_random(_First, _Dest), _STD _Range_checked_iterator_tag()));
	}

template<class _InIt, class _OutElem, size_t _Size>
inline
_OutElem* partial_sum(_InIt _First, _InIt _Last, _OutElem (&_Dest)[_Size])
	{	// compute partial sums into _Dest
	return (_First == _Last ? _Dest
		: (partial_sum(_First, _Last, _STDEXT make_checked_array_iterator(_Dest, _Size)).base()));
	}

template<class _InIt, class _OutIt>
inline
_SCL_INSECURE_DEPRECATE
_IF_NOT_CHK(_OutIt) partial_sum(_InIt _First, _InIt _Last, _OutIt _Dest)
	{	// compute partial sums into _Dest
	return (_First == _Last ? _Dest
		: _Partial_sum(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Dest,
			_Val_type(_First), _Iter_random(_First, _Dest), _STD _Range_checked_iterator_tag()));
	}

#else

template<class _InIt, class _OutIt>
inline
	_OutIt partial_sum(_InIt _First, _InIt _Last, _OutIt _Dest)
	{	// compute partial sums into _Dest
	return (_First == _Last ? _Dest
		: _Partial_sum(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Dest,
			_Val_type(_First), _Iter_random(_First, _Dest), _STD _Range_checked_iterator_tag()));
	}

#endif

		// TEMPLATE FUNCTION partial_sum WITH BINOP
template<class _InIt, class _OutIt, class _Fn2, class _Ty, class _InOutItCat>
inline
	_OutIt _Partial_sum(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func,
		_Ty *, _InOutItCat, _Range_checked_iterator_tag)
	{	// compute partial sums into _Dest, using _Func
	_DEBUG_RANGE(_First, _Last);
	_DEBUG_POINTER(_Dest);
	_DEBUG_POINTER(_Func);
	_Ty _Val = *_First;
	for (*_Dest = _Val; ++_First != _Last; *++_Dest = _Val)
		_Val = _Func(_Val, *_First);
	return (++_Dest);
	}

#if _SECURE_SCL
template<class _InIt, class _OutIt, class _Fn2, class _Ty>
inline
	_OutIt _Partial_sum(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func,
		_Ty *_Val_type, random_access_iterator_tag, _Range_checked_iterator_tag)
	{
	// for range checked iterators, this will make sure there is enough space
	_OutIt _Result = _Dest + (_Last - _First);
	_Partial_sum(_First, _Last, _CHECKED_BASE(_Dest), _Func,
		_Val_type, forward_iterator_tag(), _Range_checked_iterator_tag());
	return _Result;
	}
#endif

#if _SECURE_SCL

template<class _InIt, class _OutIt, class _Fn2>
inline
_IF_CHK(_OutIt) partial_sum(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func)
	{	// compute partial sums into _Dest, using _Func
	return (_First == _Last ? _Dest
		: _Partial_sum(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Dest, _Func,
			_Val_type(_First), _Iter_random(_First, _Dest), _STD _Range_checked_iterator_tag()));
	}

template<class _InIt, class _OutElem, class _Fn2, size_t _Size>
inline
_OutElem* partial_sum(_InIt _First, _InIt _Last,
		_OutElem (&_Dest)[_Size], _Fn2 _Func)
	{	// compute partial sums into _Dest, using _Func
	return (_First == _Last ? _Dest
		: (partial_sum(_First, _Last,
			_STDEXT make_checked_array_iterator(_Dest, _Size), _Func).base()));
	}

template<class _InIt, class _OutIt, class _Fn2>
inline
_SCL_INSECURE_DEPRECATE
_IF_NOT_CHK(_OutIt) partial_sum(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func)
	{	// compute partial sums into _Dest, using _Func
	return (_First == _Last ? _Dest
		: _Partial_sum(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Dest, _Func,
			_Val_type(_First), _Iter_random(_First, _Dest), _STD _Range_checked_iterator_tag()));
	}

#else

template<class _InIt, class _OutIt, class _Fn2>
inline
	_OutIt partial_sum(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func)
	{	// compute partial sums into _Dest, using _Func
	return (_First == _Last ? _Dest
		: _Partial_sum(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Dest, _Func,
			_Val_type(_First), _Iter_random(_First, _Dest), _STD _Range_checked_iterator_tag()));
	}

#endif

		// TEMPLATE FUNCTION adjacent_difference
template<class _InIt, class _OutIt, class _Ty, class _InOutItCat>
inline
	_OutIt _Adjacent_difference(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Ty *, _InOutItCat, _Range_checked_iterator_tag)
	{	// compute adjacent differences into _Dest
	_DEBUG_RANGE(_First, _Last);
	_DEBUG_POINTER(_Dest);
	_Ty _Val = *_First;
	for (*_Dest = _Val; ++_First != _Last; )
		{	// compute another difference
		_Ty _Tmp = *_First;
		*++_Dest = _Tmp - _Val;
		_Val = _Tmp;
		}
	return (++_Dest);
	}

#if _SECURE_SCL
template<class _InIt, class _OutIt, class _Ty>
inline
	_OutIt _Adjacent_difference(_InIt _First, _InIt _Last, _OutIt _Dest,
		_Ty *_Val_type, random_access_iterator_tag, _Range_checked_iterator_tag)
	{
	// for range checked iterators, this will make sure there is enough space
	_OutIt _Result = _Dest + (_Last - _First);
	_Adjacent_difference(_First, _Last, _CHECKED_BASE(_Dest),
		_Val_type, forward_iterator_tag(), _Range_checked_iterator_tag());
	return _Result;
	}
#endif

#if _SECURE_SCL

template<class _InIt, class _OutIt>
inline
_IF_CHK(_OutIt) adjacent_difference(_InIt _First, _InIt _Last, _OutIt _Dest)
	{	// compute adjacent differences into _Dest
	return (_First == _Last ? _Dest
		: _Adjacent_difference(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Dest,
			_Val_type(_First), _Iter_random(_First, _Dest), _STD _Range_checked_iterator_tag()));
	}

template<class _InIt, class _OutElem, size_t _Size>
inline
_OutElem* adjacent_difference(_InIt _First, _InIt _Last, _OutElem (&_Dest)[_Size])
	{	// compute adjacent differences into _Dest
	return (_First == _Last ? _Dest
		: (adjacent_difference(_First, _Last, 
			_STDEXT make_checked_array_iterator(_Dest, _Size)).base()));
	}

template<class _InIt, class _OutIt>
inline
_SCL_INSECURE_DEPRECATE
_IF_NOT_CHK(_OutIt) adjacent_difference(_InIt _First, _InIt _Last, _OutIt _Dest)
	{	// compute adjacent differences into _Dest
	return (_First == _Last ? _Dest
		: _Adjacent_difference(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Dest,
			_Val_type(_First), _Iter_random(_First, _Dest), _STD _Range_checked_iterator_tag()));
	}

#else

template<class _InIt, class _OutIt>
inline
	_OutIt adjacent_difference(_InIt _First, _InIt _Last, _OutIt _Dest)
	{	// compute adjacent differences into _Dest
	return (_First == _Last ? _Dest
		: _Adjacent_difference(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Dest,
			_Val_type(_First), _Iter_random(_First, _Dest), _STD _Range_checked_iterator_tag()));
	}

#endif

		// TEMPLATE FUNCTION adjacent_difference WITH BINOP
template<class _InIt, class _OutIt, class _Fn2, class _Ty, class _InOutItCat>
inline
	_OutIt _Adjacent_difference(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func,
		_Ty *, _InOutItCat, _Range_checked_iterator_tag)
	{	// compute adjacent differences into _Dest, using _Func
	_DEBUG_RANGE(_First, _Last);
	_DEBUG_POINTER(_Dest);
	_DEBUG_POINTER(_Func);
	_Ty _Val = *_First;
	for (*_Dest = _Val; ++_First != _Last; )
		{	// compute another difference
		_Ty _Tmp = *_First;
		*++_Dest = _Func(_Tmp, _Val);
		_Val = _Tmp;
		}
	return (++_Dest);
	}

#if _SECURE_SCL
template<class _InIt, class _OutIt, class _Fn2, class _Ty>
inline
	_OutIt _Adjacent_difference(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func,
		_Ty *_Val_type, random_access_iterator_tag, _Range_checked_iterator_tag)
	{
	// for range checked iterators, this will make sure there is enough space
	_OutIt _Result = _Dest + (_Last - _First);
	_Adjacent_difference(_First, _Last, _CHECKED_BASE(_Dest), _Func,
		_Val_type, forward_iterator_tag(), _Range_checked_iterator_tag());
	return _Result;
	}
#endif

#if _SECURE_SCL

template<class _InIt, class _OutIt, class _Fn2>
inline
_IF_CHK(_OutIt) adjacent_difference(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func)
	{	// compute adjacent differences into _Dest, using _Func
	return (_First == _Last ? _Dest :
		_Adjacent_difference(_CHECKED_BASE(_First), _CHECKED_BASE(_Last),
			_Dest, _Func,
			_Val_type(_First), _Iter_random(_First, _Dest), _STD _Range_checked_iterator_tag()));
	}

template<class _InIt, class _OutElem, class _Fn2, size_t _Size>
inline
_OutElem* adjacent_difference(_InIt _First, _InIt _Last,
		_OutElem (&_Dest)[_Size], _Fn2 _Func)
	{	// compute adjacent differences into _Dest, using _Func
	return (_First == _Last ? _Dest :
		(adjacent_difference(_First, _Last,
			_STDEXT make_checked_array_iterator(_Dest, _Size), _Func).base()));
	}

template<class _InIt, class _OutIt, class _Fn2>
inline
_SCL_INSECURE_DEPRECATE
_IF_NOT_CHK(_OutIt) adjacent_difference(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func)
	{	// compute adjacent differences into _Dest, using _Func
	return (_First == _Last ? _Dest :
		_Adjacent_difference(_CHECKED_BASE(_First), _CHECKED_BASE(_Last),
			_Dest, _Func,
			_Val_type(_First), _Iter_random(_First, _Dest), _STD _Range_checked_iterator_tag()));
	}

#else

template<class _InIt, class _OutIt, class _Fn2>
inline
	_OutIt adjacent_difference(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func)
	{	// compute adjacent differences into _Dest, using _Func
	return (_First == _Last ? _Dest :
		_Adjacent_difference(_CHECKED_BASE(_First), _CHECKED_BASE(_Last),
			_Dest, _Func,
			_Val_type(_First), _Iter_random(_First, _Dest), _STD _Range_checked_iterator_tag()));
	}

#endif

_STD_END

_STDEXT_BEGIN

template<class _InIt,
	class _OutIt> inline
	_OutIt unchecked_partial_sum(_InIt _First, _InIt _Last, _OutIt _Dest)
	{	// compute partial sums into _Dest
	return (_First == _Last ? _Dest
		: _STD _Partial_sum(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Dest,
			_STD _Val_type(_First), _STD _Iter_random(_First, _Dest), _STD _Range_checked_iterator_tag()));
	}

template<class _InIt, class _OutIt>
inline
_IF_CHK(_OutIt) checked_partial_sum(_InIt _First, _InIt _Last, _OutIt _Dest)
	{	// compute partial sums into _Dest
	return (_First == _Last ? _Dest
		: _STD _Partial_sum(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Dest,
			_STD _Val_type(_First), _STD _Iter_random(_First, _Dest), _STD _Range_checked_iterator_tag()));
	}

template<class _InIt, class _OutElem, size_t _Size>
inline
_OutElem* checked_partial_sum(_InIt _First, _InIt _Last, _OutElem (&_Dest)[_Size])
	{	// compute partial sums into _Dest
	return (_First == _Last ? _Dest
		: (checked_partial_sum(_First, _Last, _STDEXT make_checked_array_iterator(_Dest, _Size)).base()));
	}

template<class _InIt, class _OutIt>
inline
_SCL_CHECKED_ALGORITHM_WARN
_IF_NOT_CHK(_OutIt) checked_partial_sum(_InIt _First, _InIt _Last, _OutIt _Dest)
	{	// compute partial sums into _Dest
	return (_First == _Last ? _Dest
		: _STD _Partial_sum(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Dest,
			_STD _Val_type(_First), _STD _Iter_random(_First, _Dest), _STD _Range_checked_iterator_tag()));
	}

template<class _InIt,
	class _OutIt,
	class _Fn2> inline
	_OutIt unchecked_partial_sum(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func)
	{	// compute partial sums into _Dest, using _Func
	return (_First == _Last ? _Dest
		: _STD _Partial_sum(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Dest, _Func,
			_STD _Val_type(_First), _STD _Iter_random(_First, _Dest), _STD _Range_checked_iterator_tag()));
	}

template<class _InIt, class _OutIt, class _Fn2>
inline
_IF_CHK(_OutIt) checked_partial_sum(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func)
	{	// compute partial sums into _Dest, using _Func
	return (_First == _Last ? _Dest
		: _STD _Partial_sum(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Dest, _Func,
			_STD _Val_type(_First), _STD _Iter_random(_First, _Dest), _STD _Range_checked_iterator_tag()));
	}

template<class _InIt, class _OutElem, class _Fn2, size_t _Size>
inline
_OutElem* checked_partial_sum(_InIt _First, _InIt _Last,
		_OutElem (&_Dest)[_Size], _Fn2 _Func)
	{	// compute partial sums into _Dest, using _Func
	return (_First == _Last ? _Dest
		: (checked_partial_sum(_First, _Last,
			_STDEXT make_checked_array_iterator(_Dest, _Size), _Func).base()));
	}

template<class _InIt, class _OutIt, class _Fn2>
inline
_SCL_CHECKED_ALGORITHM_WARN
_IF_NOT_CHK(_OutIt) checked_partial_sum(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func)
	{	// compute partial sums into _Dest, using _Func
	return (_First == _Last ? _Dest
		: _STD _Partial_sum(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Dest, _Func,
			_STD _Val_type(_First), _STD _Iter_random(_First, _Dest), _STD _Range_checked_iterator_tag()));
	}

template<class _InIt,
	class _OutIt> inline
	_OutIt unchecked_adjacent_difference(_InIt _First, _InIt _Last, _OutIt _Dest)
	{	// compute adjacent differences into _Dest
	return (_First == _Last ? _Dest
		: _STD _Adjacent_difference(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Dest,
			_STD _Val_type(_First), _STD _Iter_random(_First, _Dest), _STD _Range_checked_iterator_tag()));
	}

template<class _InIt, class _OutIt>
inline
_IF_CHK(_OutIt) checked_adjacent_difference(_InIt _First, _InIt _Last, _OutIt _Dest)
	{	// compute adjacent differences into _Dest
	return (_First == _Last ? _Dest
		: _STD _Adjacent_difference(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Dest,
			_STD _Val_type(_First), _STD _Iter_random(_First, _Dest), _STD _Range_checked_iterator_tag()));
	}

template<class _InIt, class _OutElem, size_t _Size>
inline
_OutElem* checked_adjacent_difference(_InIt _First, _InIt _Last, _OutElem (&_Dest)[_Size])
	{	// compute adjacent differences into _Dest
	return (_First == _Last ? _Dest
		: (checked_adjacent_difference(_First, _Last, 
			_STDEXT make_checked_array_iterator(_Dest, _Size)).base()));
	}

template<class _InIt, class _OutIt>
inline
_SCL_CHECKED_ALGORITHM_WARN
_IF_NOT_CHK(_OutIt) checked_adjacent_difference(_InIt _First, _InIt _Last, _OutIt _Dest)
	{	// compute adjacent differences into _Dest
	return (_First == _Last ? _Dest
		: _STD _Adjacent_difference(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Dest,
			_STD _Val_type(_First), _STD _Iter_random(_First, _Dest), _STD _Range_checked_iterator_tag()));
	}

template<class _InIt,
	class _OutIt,
	class _Fn2> inline
	_OutIt unchecked_adjacent_difference(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func)
	{	// compute adjacent differences into _Dest, using _Func
	return (_First == _Last ? _Dest :
		_STD _Adjacent_difference(_CHECKED_BASE(_First), _CHECKED_BASE(_Last),
			_Dest, _Func,
			_STD _Val_type(_First), _STD _Iter_random(_First, _Dest), _STD _Range_checked_iterator_tag()));
	}

template<class _InIt, class _OutIt, class _Fn2>
inline
_IF_CHK(_OutIt) checked_adjacent_difference(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func)
	{	// compute adjacent differences into _Dest, using _Func
	return (_First == _Last ? _Dest :
		_STD _Adjacent_difference(_CHECKED_BASE(_First), _CHECKED_BASE(_Last),
			_Dest, _Func,
			_STD _Val_type(_First), _STD _Iter_random(_First, _Dest), _STD _Range_checked_iterator_tag()));
	}

template<class _InIt, class _OutElem, class _Fn2, size_t _Size>
inline
_OutElem* checked_adjacent_difference(_InIt _First, _InIt _Last,
		_OutElem (&_Dest)[_Size], _Fn2 _Func)
	{	// compute adjacent differences into _Dest, using _Func
	return (_First == _Last ? _Dest :
		(checked_adjacent_difference(_First, _Last,
			_STDEXT make_checked_array_iterator(_Dest, _Size), _Func).base()));
	}

template<class _InIt, class _OutIt, class _Fn2>
inline
_SCL_CHECKED_ALGORITHM_WARN
_IF_NOT_CHK(_OutIt) checked_adjacent_difference(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn2 _Func)
	{	// compute adjacent differences into _Dest, using _Func
	return (_First == _Last ? _Dest :
		_STD _Adjacent_difference(_CHECKED_BASE(_First), _CHECKED_BASE(_Last),
			_Dest, _Func,
			_STD _Val_type(_First), _STD _Iter_random(_First, _Dest), _STD _Range_checked_iterator_tag()));
	}

template<class _InIt1, class _InIt2, class _Ty>
inline
	_Ty unchecked_inner_product(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val)
	{
		return _STD _Inner_product(_CHECKED_BASE(_First1), _CHECKED_BASE(_Last1), _First2, _Val,
			_STD _Iter_random(_First1, _First2), _STD _Range_checked_iterator_tag());
	}

template<class _InIt1, class _InIt2, class _Ty>
inline
_IF_CHK_(_InIt2, _Ty) checked_inner_product(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val)
	{
	return _STD _Inner_product(_CHECKED_BASE(_First1), _CHECKED_BASE(_Last1), _First2, _Val,
		_STD _Iter_random(_First1, _First2), _STD _Range_checked_iterator_tag());
	}

template<class _InIt1, class _InElem2, class _Ty, size_t _Size>
inline
_Ty checked_inner_product(_InIt1 _First1, _InIt1 _Last1, _InElem2 (&_First2)[_Size], _Ty _Val)
	{
	return checked_inner_product(_First1, _Last1,
		_STDEXT make_checked_array_iterator(_First2, _Size), _Val);
	}

template<class _InIt1, class _InIt2, class _Ty>
inline
_SCL_CHECKED_ALGORITHM_WARN
_IF_NOT_CHK_(_InIt2, _Ty) checked_inner_product(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val)
	{
	return _STD _Inner_product(_CHECKED_BASE(_First1), _CHECKED_BASE(_Last1), _First2, _Val,
		_STD _Iter_random(_First1, _First2), _STD _Range_checked_iterator_tag());
	}

template<class _InIt1, class _InIt2, class _Ty, class _Fn21, class _Fn22>
inline
	_Ty unchecked_inner_product(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val,
		_Fn21 _Func1, _Fn22 _Func2)
	{
		return _Inner_product(_CHECKED_BASE(_First1), _CHECKED_BASE(_Last1), _First2,
			_Val, _Func1, _Func2,
			_STD _Iter_random(_First1, _First2), _STD _Range_checked_iterator_tag());
	}

template<class _InIt1, class _InIt2, class _Ty, class _Fn21, class _Fn22>
inline
_IF_CHK_(_InIt2, _Ty) checked_inner_product(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val,
		_Fn21 _Func1, _Fn22 _Func2)
	{
		return _STD _Inner_product(_CHECKED_BASE(_First1), _CHECKED_BASE(_Last1), _First2, _Val, _Func1, _Func2,
			_STD _Iter_random(_First1, _First2), _STD _Range_checked_iterator_tag());
	}

template<class _InIt1, class _InElem2, class _Ty, class _Fn21, class _Fn22, size_t _Size>
inline
_Ty checked_inner_product(_InIt1 _First1, _InIt1 _Last1, _InElem2 (&_First2)[_Size], _Ty _Val,
		_Fn21 _Func1, _Fn22 _Func2)
	{
		return checked_inner_product(_First1, _Last1,
			_STDEXT make_checked_array_iterator(_First2, _Size),
			_Val, _Func1, _Func2);
	}

template<class _InIt1, class _InIt2, class _Ty, class _Fn21, class _Fn22>
inline
_SCL_CHECKED_ALGORITHM_WARN
_IF_NOT_CHK_(_InIt2, _Ty) checked_inner_product(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val,
		_Fn21 _Func1, _Fn22 _Func2)
	{
		return _STD _Inner_product(_CHECKED_BASE(_First1), _CHECKED_BASE(_Last1), _First2, _Val, _Func1, _Func2,
			_STD _Iter_random(_First1, _First2), _STD _Range_checked_iterator_tag());
	}

 #if _HAS_TRADITIONAL_STL
template<class _FwdIt,
	class _Ty> inline
	void iota(_FwdIt _First, _FwdIt _Last, _Ty _Val)
	{	// compute increasing sequence into [_First, _Last)
	_DEBUG_RANGE(_First, _Last);
	for (; _First != _Last; ++_First, ++_Val)
		*_First = _Val;
	}
 #endif /* _HAS_TRADITIONAL_STL */

_STDEXT_END

#ifdef _MSC_VER
 #pragma warning(pop)
 #pragma pack(pop)
#endif  /* _MSC_VER */

#endif /* RC_INVOKED */
#endif /* _NUMERIC_ */

/*
 * Copyright (c) 1992-2006 by P.J. Plauger.  ALL RIGHTS RESERVED.
 * Consult your license regarding permissions and restrictions.
 */

/*
 * This file is derived from software bearing the following
 * restrictions:
 *
 * Copyright (c) 1994
 * Hewlett-Packard Company
 *
 * Permission to use, copy, modify, distribute and sell this
 * software and its documentation for any purpose is hereby
 * granted without fee, provided that the above copyright notice
 * appear in all copies and that both that copyright notice and
 * this permission notice appear in supporting documentation.
 * Hewlett-Packard Company makes no representations about the
 * suitability of this software for any purpose. It is provided
 * "as is" without express or implied warranty.
 V5.02:0009 */
